home *** CD-ROM | disk | FTP | other *** search
/ Language/OS - Multiplatform Resource Library / LANGUAGE OS.iso / a_utils / _archvrs / unix / arc521.lha / arc / arcmisc.c < prev    next >
C/C++ Source or Header  |  1989-08-08  |  9KB  |  486 lines
  1. /*
  2.  * Miscellaneous routines to get ARC running on non-MSDOS systems...
  3.  * $Header: arcmisc.c,v 1.8 88/07/31 18:50:56 hyc Exp $ 
  4.  */
  5.  
  6. #include <stdio.h>
  7. #include <ctype.h>
  8. #include "arc.h"
  9.  
  10. #if    MSDOS
  11. #include <dir.h>
  12. #include <stat.h>
  13. #endif
  14.  
  15. #if    GEMDOS
  16. #include <osbind.h>
  17. #include <stat.h>
  18. char           *index(), *rindex();
  19.  
  20. void 
  21. exitpause()
  22. {
  23.     while (Cconis())
  24.         Cnecin();
  25.     fprintf(stderr, "Press any key to continue: ");
  26.     fflush(stderr);
  27.     Cnecin();
  28.     fprintf(stderr, "\n");
  29. }
  30.  
  31. int
  32. chdir(dirname)
  33.     char           *dirname;
  34. {
  35.     char           *i;
  36.     int             drv;
  37.  
  38.     i = dirname;
  39.     if ((i = index(dirname, ':')) != NULL) {
  40.         drv = i[-1];
  41.         i++;        /* Move past device spec */
  42.         if (drv > '\'')
  43.             drv -= 'a';
  44.         else
  45.             drv -= 'A';
  46.         if (drv >= 0 && drv < 16)
  47.             Dsetdrv(drv);
  48.     }
  49.     if (*i != '\0')
  50.         return (Dsetpath(i));
  51. }
  52. #endif
  53.  
  54. #if    UNIX
  55. #include <sys/types.h>
  56. #if    MINIX
  57. #include <dirent.h>
  58. #define DIRECT dirent
  59. #else
  60. #include <sys/dir.h>
  61. #endif
  62. #include <sys/stat.h>
  63.     int    rename(), unlink();
  64. #endif
  65.  
  66. #if    SYSV
  67. #include <dirent.h>
  68. #define DIRECT dirent
  69. #else
  70. #ifndef MINIX
  71. #define DIRECT direct
  72. #endif
  73. #endif
  74.  
  75. #if    BSD
  76. char    *
  77. memset(s, c, n)        /* oops. Thought it was standard BSD, but my Sun */
  78.     char    *s;    /* fooled me again. -- hyc */
  79.     int    c, n;
  80. {
  81.     register int i;
  82.     for(i=0;i<n;i++)
  83.         s[i]=c;
  84.     return(s);
  85. }
  86. #endif
  87.  
  88. char           *strcpy(), *strcat(), *malloc();
  89. int             strlen(), strcmp(), match();
  90.  
  91. int
  92. move(oldnam, newnam)
  93.     char           *oldnam, *newnam;
  94. {
  95.     FILE           *fopen(), *old, *new;
  96. #if    !MTS
  97.     struct stat     oldstat;
  98. #endif
  99.     char           *strcpy();
  100.     void        filecopy();
  101. #if    GEMDOS
  102.     if (Frename(0, oldnam, newnam))
  103. #else
  104.     if (rename(oldnam, newnam))
  105. #endif
  106. #if    !MTS
  107.     {
  108.         if (stat(oldnam, &oldstat))    /* different partition? */
  109.             return (-1);
  110.         old = fopen(oldnam, OPEN_R);
  111.         if (old == NULL)
  112.             return (-1);
  113.         new = fopen(newnam, OPEN_W);
  114.         if (new == NULL)
  115.             return (-1);
  116.         filecopy(old, new, oldstat.st_size);
  117.         return(unlink(oldnam));
  118.     }
  119.     return 0;
  120. #else
  121.     return(-1);
  122. #endif
  123. }
  124.  
  125. static void
  126. _makefn(source, dest)
  127.     char           *source;
  128.     char           *dest;
  129. {
  130.     int             j;
  131. #if    MSDOS
  132.     char           *setmem();
  133. #else
  134.     char           *memset();
  135. #endif
  136.  
  137.     setmem(dest, 17, 0);    /* clear result field */
  138.     for (j = 0; *source && *source != '.'; ++source)
  139.         if (j < 8)
  140.             dest[j++] = *source;
  141.     for (j = 9; *source; ++source)
  142.         if (j < 13)
  143.             dest[j++] = *source;
  144. }
  145. /*
  146.  * make a file name using a template 
  147.  */
  148.  
  149. char           *
  150. makefnam(rawfn, template, result)
  151.     char           *rawfn;    /* the original file name */
  152.     char           *template;    /* the template data */
  153.     char           *result;    /* where to place the result */
  154. {
  155.     char            et[17], er[17], rawbuf[STRLEN], *i, *rindex();
  156.  
  157.     *rawbuf = 0;
  158.     strcpy(rawbuf, rawfn);
  159. #if    MTS
  160.     i = rawbuf;
  161.     if (rawbuf[0] == tmpchr[0]) {
  162.         i++;
  163.         strcpy(rawfn, i);
  164.     } else
  165. #endif
  166.     if ((i = rindex(rawbuf, CUTOFF))) {
  167.         i++;
  168.         strcpy(rawfn, i);
  169.     }
  170. #if    DOS
  171.     else if ((i = rindex(rawbuf, ':'))) {
  172.         i++;
  173.         strcpy(rawfn, i);
  174.     }
  175. #endif
  176.     if (i)
  177.         *i = 0;
  178.     else
  179.         *rawbuf = 0;
  180.  
  181.     _makefn(template, et);
  182.     _makefn(rawfn, er);
  183.     *result = 0;        /* assure no data */
  184.     strcat(result, rawbuf);
  185.     strcat(result, er[0] ? er : et);
  186.     strcat(result, er[9] ? er + 9 : et + 9);
  187.     return ((char *) &result[0]);
  188. }
  189.  
  190. #if    MSDOS || SYSV || MINIX
  191.  
  192. int
  193. alphasort(dirptr1, dirptr2)
  194.     struct DIRECT **dirptr1, **dirptr2;
  195. {
  196.     return (strcmp((*dirptr1)->d_name, (*dirptr2)->d_name));
  197. }
  198.  
  199. #endif
  200.  
  201. void
  202. upper(string)
  203.     char           *string;
  204. {
  205.     char           *p;
  206.  
  207.     for (p = string; *p; p++)
  208.         if (islower(*p))
  209.             *p = toupper(*p);
  210. }
  211. /* VARARGS1 */
  212. void
  213. abort(s, arg1, arg2, arg3)
  214.     char           *s;
  215. {
  216.     fprintf(stderr, "ARC: ");
  217.     fprintf(stderr, s, arg1, arg2, arg3);
  218.     fprintf(stderr, "\n");
  219. #if    UNIX
  220.     perror("UNIX");
  221. #endif
  222. #if    GEMDOS
  223.     exitpause();
  224. #endif
  225.     exit(1);
  226. }
  227.  
  228. #if    !MTS
  229.  
  230. char           *
  231. gcdir(dirname)
  232.     char           *dirname;
  233.  
  234. {
  235.     char           *getwd();
  236. #if    GEMDOS
  237.     int             drv;
  238.     char           *buf;
  239. #endif
  240.     if (dirname == NULL || strlen(dirname) == 0)
  241.         dirname = (char *) malloc(1024);
  242.  
  243. #if    !GEMDOS
  244.     getwd(dirname);
  245. #else
  246.     buf = dirname;
  247.     *buf++ = (drv = Dgetdrv()) + 'A';
  248.     *buf++ = ':';
  249.     Dgetpath(buf, 0);
  250. #endif
  251.     return (dirname);
  252. }
  253.  
  254. #if    UNIX
  255. char           *pattern;    /* global so that fmatch can use it */
  256. #endif
  257.  
  258. char           *
  259. dir(filename)        /* get files, one by one */
  260.     char           *filename;    /* template, or NULL */
  261. {
  262. #if    GEMDOS
  263.     static int      Nnum = 0;
  264.     static DMABUFFER dbuf, *saved;
  265.     char           *name;
  266.  
  267.     if (Nnum == 0) {    /* first call */
  268.         saved = (DMABUFFER *) Fgetdta();
  269.         Fsetdta(&dbuf);
  270.         if (Fsfirst(filename, 0) == 0) {
  271.             name = malloc(FNLEN);
  272.             strcpy(name, dbuf.d_fname);
  273.             Nnum++;
  274.             return (name);
  275.         } else {
  276.             Fsetdta(saved);
  277.             return (NULL);
  278.         }
  279.     } else {
  280.         if (Fsnext() == 0) {
  281.             name = malloc(FNLEN);
  282.             strcpy(name, dbuf.d_fname);
  283.             return (name);
  284.         } else {
  285.             Nnum = 0;
  286.             Fsetdta(saved);
  287.             return (NULL);
  288.         }
  289.     }
  290. }
  291. #else
  292.     static struct DIRECT **namelist;
  293.     static char   **NameList;
  294.     static char    namecopy[STRLEN], *dirname;
  295. #if    UNIX
  296.     int             alphasort();
  297.     int             scandir();
  298. #endif                /* UNIX */
  299.     int             fmatch(), free();
  300.     static int      Nnum = 0, ii;
  301.     char        *rindex();
  302.  
  303.  
  304.     if (Nnum == 0) {    /* first call */
  305.         strcpy(namecopy,filename);
  306.         if(pattern=rindex(namecopy,CUTOFF)) {
  307.             *pattern = 0;
  308.             pattern++;
  309.             dirname = namecopy;
  310.         } else {
  311.             pattern = filename;
  312.             dirname = ".";
  313.         }
  314.         Nnum = scandir(dirname, &namelist, fmatch, alphasort);
  315.         NameList = (char **) malloc(Nnum * sizeof(char *));
  316.         for (ii = 0; ii < Nnum; ii++) {
  317.             (NameList)[ii] = malloc(strlen(namelist[ii]->d_name) + 1);
  318.             strcpy((NameList)[ii], namelist[ii]->d_name);
  319.         }
  320.         ii = 0;
  321.     }
  322.     if (ii >= Nnum) {    /* all out of files */
  323.         if (Nnum) {    /* there were some files found */
  324.             for (ii = 0; ii < Nnum; ii++)
  325.                 free(namelist[ii]);
  326.             free(namelist);
  327.         }
  328.         Nnum = 0;
  329.         return (NULL);
  330.     } else {
  331.         return ((NameList)[ii++]);
  332.     }
  333. }
  334.  
  335. /*
  336.  * Filename match - here, * matches everything 
  337.  */
  338.  
  339. int
  340. fmatch(direntry)
  341.     struct DIRECT  *direntry;
  342. {
  343.     char           *string;
  344.  
  345.     string = direntry->d_name;
  346.  
  347.     if (!strcmp(pattern, "") || !strcmp(pattern, "*.*") || !strcmp(pattern, "*"))
  348.         return (1);
  349.     return (match(string, pattern));
  350. }
  351. #endif                /* GEMDOS */
  352. #else
  353. /* dir code for MTS under Bell Labs C... */
  354.  
  355. char           *
  356. dir(filepattern)
  357.     char           *filepattern;    /* template or NULL */
  358. {
  359.     char           *malloc(), *index();
  360. #if    USECATSCAN
  361.     fortran void    catscan(), fileinfo();
  362.  
  363.     struct catname {
  364.         short           len;
  365.         char            name[257];
  366.     }               pattern;
  367.  
  368.     struct catval {
  369.         int             maxlen;
  370.         int             actlen;
  371.         char            name[257];
  372.     }               catreturn;
  373.  
  374.     char           *i;
  375.     int             j, RETCODE;
  376.  
  377.     static int      catptr = 0;
  378.     static int      catflag = 0x200;
  379.     static int      cattype = 1;
  380.     static int      patflag = 0;
  381.  
  382.     catreturn.maxlen = 256;
  383.  
  384.     if (patflag) {
  385.         patflag = 0;
  386.         catptr = 0;
  387.         return (NULL);
  388.     }
  389.     if (filepattern) {
  390.         strcpy(pattern.name, filepattern);
  391.         pattern.len = strlen(filepattern);
  392.         if (!index(filepattern, '?'))
  393.             patflag = 1;
  394.     }
  395.     if (patflag) {
  396.         fileinfo(&pattern, &cattype, "CINAME  ", &catreturn, _retcode RETCODE);
  397.         catptr = RETCODE ? 0 : 1;
  398.     } else
  399.         catscan(&pattern, &catflag, &cattype, &catreturn, &catptr);
  400.  
  401.     if (!catptr)
  402.         return (NULL);
  403.     else {
  404.         char           *k;
  405.  
  406.         k = index(catreturn.name, ' ');
  407.         if (k)
  408.             *k = 0;
  409.         else {
  410.             j = catreturn.actlen;
  411.             catreturn.name[j] = 0;
  412.         }
  413.         k = catreturn.name;
  414.         if (catreturn.name[0] == tmpchr[0])
  415.             k++;
  416.         else if ((k = index(catreturn.name, sepchr[0])))
  417.             k++;
  418.         else
  419.             k = catreturn.name;
  420.         j = strlen(k);
  421.         i = malloc(++j);
  422.         strcpy(i, k);
  423.         return (i);
  424.     }
  425. #else
  426.     fortran void    gfinfo();
  427.     static char     gfname[24];
  428.     static char     pattern[20];
  429.     static int      gfdummy[2] = {
  430.                       0, 0
  431.     },              gfflags;
  432.     int             i, RETCODE;
  433.     char           *j, *k;
  434.  
  435.     if (filepattern) {
  436.         strcpy(pattern, filepattern);
  437.         strcat(pattern, " ");
  438.         for (i = 20; i < 24; i++)
  439.             gfname[i] = '\0';
  440.         if (index(pattern, '?'))
  441.             gfflags = 0x0C;
  442.         else
  443.             gfflags = 0x09;
  444.     } else if (gfflags == 0x09)
  445.         return (NULL);
  446.  
  447.     gfinfo(pattern, gfname, &gfflags, gfdummy, gfdummy, gfdummy, _retcode RETCODE);
  448.     if (RETCODE)
  449.         return (NULL);
  450.     else {
  451.         k = index(gfname, ' ');
  452.         *k = '\0';
  453.         k = gfname;
  454.         if (gfname[0] == tmpchr[0])
  455.             k++;
  456.         else if ((k = index(gfname, sepchr[0])))
  457.             k++;
  458.         else
  459.             k = gfname;
  460.         i = strlen(k);
  461.         j = malloc(++i);
  462.         strcpy(j, k);
  463.         return (j);
  464.     }
  465. #endif
  466. }
  467.  
  468. int
  469. unlink(path)
  470.     char           *path;    /* name of file to delete */
  471. {
  472.     fortran void    destroy();
  473.     int             RETCODE;
  474.  
  475.     char            name[258];
  476.  
  477.     strcpy(name, path);
  478.     strcat(name, " ");
  479.     destroy(name, _retcode RETCODE);
  480.     if (RETCODE)
  481.         return (-1);
  482.     else
  483.         return (0);
  484. }
  485. #endif
  486.